home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Technotools
/
Technotools (Chestnut CD-ROM)(1993).ISO
/
lang_c
/
13h_kit
/
images.hpp
< prev
next >
Wrap
C/C++ Source or Header
|
1991-07-04
|
13KB
|
283 lines
//*************************************************************************
// IMAGES.HPP -Header file for basic graphics operations and PCX *
// image decoding in graphics mode 13h *
// *
// Copyright 1991 by the Gamers Programming Workshop, a function of the *
// GAMERS forum, Compuserve. For more info e-mail 76605,2346. *
// *
// License is granted for use or modification of this code as long as *
// this notice remains intact, and all improvements are listed in the *
// version history below, and uploaded to the GAMERS forum. This code *
// may not be used for any commercial purpose. *
//*************************************************************************
//*************************************************************************
// Version history: *
// *
// Version 1.0 *
// Developed: May 2, 1991 *
// Author: Mark Betz, 76605,2346 *
// Last update: July 5, 1991 *
//*************************************************************************
// ************************************************************************
// The functions and class structures declared in this header provide some
// basic tools for 256 color mode 13h. Tools are provided for initializing
// a pcx graphic file, unpacking PCX encoded data, setting text and graphics
// modes, loading the dac palette, reading the dac palette, writing a pixel
// reading a pixel, bar fills, and fast line drawing. In addition, the class
// font provides methods for displaying and reading strings in a bitmapped
// font. See images.doc for info on images tools, and font.doc for info on
// using the font class.
// ************************************************************************
// ************************************************************************
// this is the 128 byte header at the front of all PCX files. In 256 color
// mode 0x13 the palette structure is ignored, and the palette can be found
// in the last 768 bytes of the file.
// ************************************************************************
struct pcx_hdr {
char Mfg; // manufacturer, always 0xa0
char Ver; // encoder version number
char Enc; // encoding code, always 1
char Bpp; // bits per pixel, 8 in mode 0x13
int Xmin,Ymin; // image origin, usually 0,0
int Xmax,Ymax; // image dimensions
int Hres; // horizontal resolution value
int Vres; // vertical resolution value
char Pal[48]; // palette (not in mode 0x13)
char Reserved; // who knows?
char ClrPlanes; // number of planes, 1 in mode 0x13
int Bpl; // bytes per line, 80 in mode 0x13
int PalType; // Grey or Color palette flag
char Filler[58]; // Zsoft wanted a 128 byte header
};
// **************************************************************************
// p_rec is the primary rgb dac palette structure type
// **************************************************************************
typedef char p_rec[256][3]; // basic rgb palette structure type
// **************************************************************************
// this enum is used to specify in several places how the background will be
// treated.
// **************************************************************************
enum opacity {trans,opaque};
// **************************************************************************
// declaration of font class (see font.doc). All methods define in images.cpp
// **************************************************************************
class font { // generic font class
public:
opacity see_thru; // background treatment
font(char *f_spec); // constructor, pass file name
void setstyle(int f_grnd, int b_grnd,
short char_tab, opacity o,
char space_wid);
int getforecolor(); // get current text color
int getbackcolor(); // get current background color
void show(int x, int y,char *str); // show a string at x,y
void readstr(int x, int y,char *str,
char length, char mask); // read a string from keyboard
int installed(); // returns 1 if font installed
~font(); // destructor frees font memory
private:
struct font_hdr { // font description structure
char font_name[8]; // font name, no file extension
char fram_wid; // width of character frame in pixels
char fram_hit; // height of character frame in pixels
char base_ofs; // baseline y offset from top
char ascii_first; // number of first character defined
char ascii_last; // number of last character defined
char f_color; // original font foreground color
} f_hdr;
char width[128]; // character width table
char spacing; // pixels between characters
char far *font_ptr; // pointer to font in memory
char far *cursor_mask; // pointer to cursor mask in memory
int fore_color; // holds current text color
int back_color; // holds current background color
int status; // non 0 if installation successful
void put_char(int x, int y, // display a single character
char c);
char get_width(char c);
};
// *************************************************************************
// The i_stack class was originally envisioned as a pointer stack for the
// use of a window management class that would create cascaded windows by
// allocating pointers to win class objects and pushing them onto the
// pointer stack. A close() method would close the last opened window. For
// now this is on the back burner. If you see a use for the pointer stack
// be aware that I haven't tested it at all. Should work <g>.
// *************************************************************************
class i_stack {
public:
i_stack(); // constructor
char push_ptr(void far *ptr); // push a pointer on to stack
void *pop_ptr(); // pop a pointer from the stack
private:
void far *ptr_array[20]; // pointer container
char ptr_index; // index to next open element
};
// *************************************************************************
// Class win is a pop up window class. A win object allocates memory for,
// and saves it's own background. So consecutive windows can be opened, and
// each will restore the background as it goes out of scope, or as it is
// deleted(), depending on how it was opened. See WIN.DOC for a brief des-
// cription.
// *************************************************************************
class win {
public:
char status; // 1 if window opened successfully
win(int tlx, int tly, int xwid, int ywid, char *bmap,
char brdrwid, char shdwwid, char bgrnd, char border);
char installed(){return(status);} // returns the status value
~win();
private:
char far *backgrnd; // pointer to background bitmap
int origX; // top left x coord of the window
int origY; // top left y coord of the window
int xsize; // window x dimension in pixels
int ysize; // window y dimension in pixels
char bdrwid; // border width, 0 if no border
char shdwid; // shadow width, 0 if no shadow
char shdwon; // 1 if shadow is on, 0 if not
char b_grnd; // window background color
char brdr; // border color, ignored if bdrwid=0;
};
class image {
public:
p_rec palette; // holds the default image palette
char fpath[80]; // stores the disk path to image
char getstatus() {return(status);} // returns status of last op
// 1 if successful, 0 if not
protected:
char in_ram; // 1 if image in ram, 0 if not
char packed; // 1 if packed in ram, 0 if not
char status; // returned by getstatus()
char far *buffer; // pointer for ram buffer if any
};
class pcx : public image {
public:
pcx(char *fspec); // constructor
char load(char method); // load into ram packed or unpacked
void unload(); // unload from ram
char display(char fadetype); // display image using fadetype
void remove(char fadetype); // remove image using fadetype
~pcx(); // destructor
private:
char unpacktoram(char far *dest, // internal, unpack to memory
unsigned numbytes);
};
// image fade constants ***************************************************
const char SnapWipe = 0; // simple block copy to vram
const char SplitVerticalWipe = 1; // fades from top and bottom
const char SplitHorizWipe = 2; // fades from right and left
const char SlideVerticalWipe = 3; // slides image in from right and left
const char SlideHorizWipe = 4; // slides image in from top and bottom
const char VerticalDissolve = 5; // fades multiple vertical slices
const char HorizDissolve = 6; // fades multiple horizontal slices
const char SparkleDissolve = 7; // fades with random pixel placement
const char SoftFade=8; // does a palette shifted fade
// error reporting constants **********************************************
const char NoErr = 0; // no error occured
const char MemErr = 1; // error occured allocating memory
const char FileReadErr = 2; // error occured reading a file
const char FileWriteErr = 3; // error occured writing a file
const char FileMakeErr = 4; // error occured creating a file
const char FileOpenErr = 5; // error occured opening file
const char FileFormatErr = 6; // bad file format error
const char SecondaryErr = 7; // error occured in subroutine during call
const char UnknownErr = 8; // an unknown error occured
// For use with type PRec *************************************************
const short Red = 0; // constants used with type PRec
const short Green = 1; // example: PRec Palette;
const short Blue = 2; // Palette[0][Green]=63;
// for use with call to pcx::load() ***************************************
const char Packed = 0; // load image in compressed form
const char Unpacked = 1; // load image in uncompressed form
const char Bestfit = 2; // load compressed or uncompressed
// Function prototypes ****************************************************
extern void unpackpcx(FILE *pcx, const char far *source,
char far *dest, unsigned int num_bytes);
// **** System level graphics functions ***********************************
extern void setgraphmode();
extern void settextmode();
extern void wait_vbi();
extern void reporterr(char type, char where[30]);
// **** DAC palette functions *********************************************
extern void loadpalette(int start, int number, const p_rec palette);
extern void readpalette(int start, int number, p_rec palette);
extern void clrpalette(int start, int number);
extern void fadepalettein(int start, int count, const p_rec palette);
extern void fadepaletteout(int start, int count);
// **** Graphics segment redirection **************************************
extern void setgraphseg(unsigned newseg);
// **** Drawing primitives ************************************************
extern void clearscr(int color);
extern void barfill(int tlx, int tly, int brx, int bry, int color);
extern void writepixel(int x, int y, int color);
extern char readpixel(int x, int y);
extern void far *xy_to_ptr(int x, int y);
extern void line(int x0, int y0, int x1, int y1, int color);
// **** Image block copying functions *************************************
extern void getimage(int x0, int y0, int x1, int y1, char far *buff);
extern void putimage(int x0, int y0, int x1, int y1, char far *buff);
extern void copyimage(int x0, int y0, int x1, int y1, int putx, int puty,
void far *src_buf);
// **** Image fades and dissolve functions ********************************
extern void doSplitVerticalWipe(void far *pic_buf);
extern void doSplitHorizWipe(void far *pic_buf);
extern void doSlideVerticalWipe(void far *pic_buf);
extern void doSlideHorizWipe(void far *pic_buf);
extern void doVerticalDissolve(void far *pic_buf);
extern void doHorizDissolve(void far *pic_buf);
extern void doSparkleDissolve(void far *pic_buf);
// ***********************************************************************